
声明 模块 "child_process" {
    //@@{ 事件组:events }
    导入 * 转为 事件组 来自 "events";
    //@@{ 网络:net }
    导入 * 转为 网络 来自 "net";

    //@@{ 可写的_:Writable, 可读的_:Readable, 流_:Stream, 管道_:Pipe }
    导入 { 可写的_, 可读的_, 流_, 管道_ } 来自 "stream";

    //@@{ 子进程_:ChildProcess, 事件组:events, 事件发生器_:EventEmitter }
    接口 子进程_ 扩展 事件组.事件发生器_ {

        //@@{ 标准输入:stdin, 可写的_:Writable }
        标准输入: 可写的_ | 空值;

        //@@{ 标准输出:stdout, 可读的_:Readable }
        标准输出: 可读的_ | 空值;

        //@@{ 标准错误:stderr, 可读的_:Readable }
        标准错误: 可读的_ | 空值;

        //@@{ 通道:channel, 管道_:Pipe }
        只读 通道?: 管道_ | 空值;

        //@@{ 标准输入输出:stdio }
        只读 标准输入输出: [

            //@@{ 可写的_:Writable }
            可写的_ | 空值, // stdin

            //@@{ 可读的_:Readable }
            可读的_ | 空值, // stdout

            //@@{ 可读的_:Readable }
            可读的_ | 空值, // stderr

            //@@{ 可读的_:Readable, 可写的_:Writable }
            可读的_ | 可写的_ | 空值 | 未定, // extra

            //@@{ 可读的_:Readable, 可写的_:Writable }
            可读的_ | 可写的_ | 空值 | 未定 // extra
        ];

        //@@{ 杀了:killed }
        只读 杀了: 真假;
        只读 pid: 数字;

        //@@{ 连接了:connected }
        只读 连接了: 真假;

        //@@{ 杀死:kill }
        杀死(信号?: 文字): 无值;

        //@@{ 发送:send, 错误_:Error }
        发送(消息: 任意, 回调?: (错误: 错误_ | 空值) => 无值): 真假;

        //@@{ 发送:send, 网络:net, 套接字_:Socket, 服务器_:Server, 错误_:Error }
        发送(消息: 任意, 发送处理?: 网络.套接字_ | 网络.服务器_, 回调?: (错误: 错误_ | 空值) => 无值): 真假;

        //@@{ 发送:send, 网络:net, 套接字_:Socket, 服务器_:Server, 消息选项_:MessageOptions, 错误_:Error }
        发送(消息: 任意, 发送处理?: 网络.套接字_ | 网络.服务器_, 选项组?: 消息选项_, 回调?: (错误: 错误_ | 空值) => 无值): 真假;

        //@@{ 断开连接:disconnect }
        断开连接(): 无值;

        //@@{ 解除限制:unref }
        解除限制(): 无值;

        //@@{ 限制退出:ref }
        限制退出(): 无值;

        /**
         * events.EventEmitter
         * 1. close
         * 2. disconnect
         * 3. error
         * 4. exit
         * 5. message
         */

        //@@{ 添加监听器:addListener }
        添加监听器(事件: 文字, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 添加监听器:addListener, "关闭":"close" }
        添加监听器(事件: "关闭", 监听器: (代码: 数字, 信号: 文字) => 无值): 本体;

        //@@{ 添加监听器:addListener, "断开连接":"disconnect" }
        添加监听器(事件: "断开连接", 监听器: () => 无值): 本体;

        //@@{ 添加监听器:addListener, "错误":"error", 错误_:Error }
        添加监听器(事件: "错误", 监听器: (错: 错误_) => 无值): 本体;

        //@@{ 添加监听器:addListener, "退出":"exit" }
        添加监听器(事件: "退出", 监听器: (代码: 数字 | 空值, 信号: 文字 | 空值) => 无值): 本体;

        //@@{ 添加监听器:addListener, "消息":"message", 网络:net, 套接字_:Socket, 服务器_:Server }
        添加监听器(事件: "消息", 监听器: (消息: 任意, 发送处理: 网络.套接字_ | 网络.服务器_) => 无值): 本体;

        //@@{ 发出:emit }
        发出(事件: 文字 | 符号, ...参数组: 任意[]): 真假;

        //@@{ 发出:emit, "关闭":"close" }
        发出(事件: "关闭", 代码: 数字, 信号: 文字): 真假;

        //@@{ 发出:emit, "断开连接":"disconnect" }
        发出(事件: "断开连接"): 真假;

        //@@{ 发出:emit, "错误":"error", 错误_:Error }
        发出(事件: "错误", 错: 错误_): 真假;

        //@@{ 发出:emit, "退出":"exit" }
        发出(事件: "退出", 代码: 数字 | 空值, 信号: 文字 | 空值): 真假;

        //@@{ 发出:emit, "消息":"message", 网络:net, 套接字_:Socket, 服务器_:Server }
        发出(事件: "消息", 消息: 任意, 发送处理: 网络.套接字_ | 网络.服务器_): 真假;

        //@@{ 正在:on }
        正在(事件: 文字, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 正在:on, "关闭":"close" }
        正在(事件: "关闭", 监听器: (代码: 数字, 信号: 文字) => 无值): 本体;

        //@@{ 正在:on, "断开连接":"disconnect" }
        正在(事件: "断开连接", 监听器: () => 无值): 本体;

        //@@{ 正在:on, "错误":"error", 错误_:Error }
        正在(事件: "错误", 监听器: (错: 错误_) => 无值): 本体;

        //@@{ 正在:on, "退出":"exit" }
        正在(事件: "退出", 监听器: (代码: 数字 | 空值, 信号: 文字 | 空值) => 无值): 本体;

        //@@{ 正在:on, "消息":"message", 网络:net, 套接字_:Socket, 服务器_:Server }
        正在(事件: "消息", 监听器: (消息: 任意, 发送处理: 网络.套接字_ | 网络.服务器_) => 无值): 本体;

        //@@{ 一次:once }
        一次(事件: 文字, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 一次:once, "关闭":"close" }
        一次(事件: "关闭", 监听器: (代码: 数字, 信号: 文字) => 无值): 本体;

        //@@{ 一次:once, "断开连接":"disconnect" }
        一次(事件: "断开连接", 监听器: () => 无值): 本体;

        //@@{ 一次:once, "错误":"error", 错误_:Error }
        一次(事件: "错误", 监听器: (错: 错误_) => 无值): 本体;

        //@@{ 一次:once, "退出":"exit" }
        一次(事件: "退出", 监听器: (代码: 数字 | 空值, 信号: 文字 | 空值) => 无值): 本体;

        //@@{ 一次:once, "消息":"message", 网络:net, 套接字_:Socket, 服务器_:Server }
        一次(事件: "消息", 监听器: (消息: 任意, 发送处理: 网络.套接字_ | 网络.服务器_) => 无值): 本体;

        //@@{ 预处理监听器:prependListener }
        预处理监听器(事件: 文字, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "关闭":"close" }
        预处理监听器(事件: "关闭", 监听器: (代码: 数字, 信号: 文字) => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "断开连接":"disconnect" }
        预处理监听器(事件: "断开连接", 监听器: () => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "错误":"error", 错误_:Error }
        预处理监听器(事件: "错误", 监听器: (错: 错误_) => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "退出":"exit" }
        预处理监听器(事件: "退出", 监听器: (代码: 数字 | 空值, 信号: 文字 | 空值) => 无值): 本体;

        //@@{ 预处理监听器:prependListener, "消息":"message", 网络:net, 套接字_:Socket, 服务器_:Server }
        预处理监听器(事件: "消息", 监听器: (消息: 任意, 发送处理: 网络.套接字_ | 网络.服务器_) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener }
        预处理一次监听器(事件: 文字, 监听器: (...参数组: 任意[]) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "关闭":"close" }
        预处理一次监听器(事件: "关闭", 监听器: (代码: 数字, 信号: 文字) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "断开连接":"disconnect" }
        预处理一次监听器(事件: "断开连接", 监听器: () => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "错误":"error", 错误_:Error }
        预处理一次监听器(事件: "错误", 监听器: (错: 错误_) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "退出":"exit" }
        预处理一次监听器(事件: "退出", 监听器: (代码: 数字 | 空值, 信号: 文字 | 空值) => 无值): 本体;

        //@@{ 预处理一次监听器:prependOnceListener, "消息":"message", 网络:net, 套接字_:Socket, 服务器_:Server }
        预处理一次监听器(事件: "消息", 监听器: (消息: 任意, 发送处理: 网络.套接字_ | 网络.服务器_) => 无值): 本体;
    }

    // return this object when stdio option is undefined or not specified

    //@@{ 子进程不含空流_:ChildProcessWithoutNullStreams, 子进程_:ChildProcess }
    接口 子进程不含空流_ 扩展 子进程_ {

        //@@{ 标准输入:stdin, 可写的_:Writable }
        标准输入: 可写的_;

        //@@{ 标准输出:stdout, 可读的_:Readable }
        标准输出: 可读的_;

        //@@{ 标准错误:stderr, 可读的_:Readable }
        标准错误: 可读的_;

        //@@{ 标准输入输出:stdio }
        只读 标准输入输出: [

            //@@{ 可写的_:Writable }
            可写的_, // stdin

            //@@{ 可读的_:Readable }
            可读的_, // stdout

            //@@{ 可读的_:Readable }
            可读的_, // stderr

            //@@{ 可读的_:Readable, 可写的_:Writable }
            可读的_ | 可写的_ | 空值 | 未定, // extra, no modification

            //@@{ 可读的_:Readable, 可写的_:Writable }
            可读的_ | 可写的_ | 空值 | 未定 // extra, no modification
        ];
    }

    //@@{ 消息选项_:MessageOptions }
    接口 消息选项_ {

        //@@{ 保持打开:keepOpen }
        保持打开?: 真假;
    }

    //@@{ 标准输入输出选项_:StdioOptions, "管道":"pipe", "忽略":"ignore", "继承":"inherit", 数组_:Array, 流_:Stream }
    类型 标准输入输出选项_ = "管道" | "忽略" | "继承" | 数组_<("管道" | "ipc" | "忽略" | "继承" | 流_ | 数字 | 空值 | 未定)>;

    //@@{ 进程环境选项_:ProcessEnvOptions }
    接口 进程环境选项_ {

        //@@{ 用户Id:uid }
        用户Id?: 数字;

        //@@{ 组Id:gid }
        组Id?: 数字;

        //@@{ 工作目录:cwd }
        工作目录?: 文字;

        //@@{ 环境变量:env, 进程环境变量_:ProcessEnv }
        环境变量?: NodeJS.进程环境变量_;
    }

    //@@{ 共同选项_:CommonOptions, 进程环境选项_:ProcessEnvOptions }
    接口 共同选项_ 扩展 进程环境选项_ {
        /**
         * @default true
         */

        //@@{ 窗口隐藏:windowsHide }
        窗口隐藏?: 真假;
        /**
         * @default 0
         */

        //@@{ 超时:timeout }
        超时?: 数字;
    }

    //@@{ 启动进程选项_:SpawnOptions, 共同选项_:CommonOptions }
    接口 启动进程选项_ 扩展 共同选项_ {

        //@@{ 参数v0:argv0 }
        参数v0?: 文字;

        //@@{ 标准输入输出:stdio, 标准输入输出选项_:StdioOptions }
        标准输入输出?: 标准输入输出选项_;

        //@@{ 与主进程分离:detached }
        与主进程分离?: 真假;

        //@@{ 界面:shell }
        界面?: 真假 | 文字;

        //@@{ 窗口逐字参数:windowsVerbatimArguments }
        窗口逐字参数?: 真假;
    }

    //@@{ 派生选项不含标准输入输出_:SpawnOptionsWithoutStdio, 启动进程选项_:SpawnOptions }
    接口 派生选项不含标准输入输出_ 扩展 启动进程选项_ {

        //@@{ 标准输入输出:stdio, "管道":"pipe", 数组_:Array }
        标准输入输出?: "管道" | 数组_<空值 | 未定 | "管道">;
    }

    //@@{ 启动进程:spawn, 派生选项不含标准输入输出_:SpawnOptionsWithoutStdio, 子进程不含空流_:ChildProcessWithoutNullStreams }
    函数 启动进程(命令: 文字, 选项组?: 派生选项不含标准输入输出_): 子进程不含空流_;

    //@@{ 启动进程:spawn, 启动进程选项_:SpawnOptions, 子进程_:ChildProcess }
    函数 启动进程(命令: 文字, 选项组: 启动进程选项_): 子进程_;

    //@@{ 启动进程:spawn, 只读数组_:ReadonlyArray, 派生选项不含标准输入输出_:SpawnOptionsWithoutStdio }
    //@@{ 子进程不含空流_:ChildProcessWithoutNullStreams }
    函数 启动进程(命令: 文字, 参数组?: 只读数组_<文字>, 选项组?: 派生选项不含标准输入输出_): 子进程不含空流_;

    //@@{ 启动进程:spawn, 只读数组_:ReadonlyArray, 启动进程选项_:SpawnOptions, 子进程_:ChildProcess }
    函数 启动进程(命令: 文字, 参数组: 只读数组_<文字>, 选项组: 启动进程选项_): 子进程_;

    //@@{ 执行命令选项_:ExecOptions, 共同选项_:CommonOptions }
    接口 执行命令选项_ 扩展 共同选项_ {

        //@@{ 界面:shell }
        界面?: 文字;

        //@@{ 最大缓冲区:maxBuffer }
        最大缓冲区?: 数字;

        //@@{ 杀死信号:killSignal }
        杀死信号?: 文字;
    }

    //@@{ 执行命令选项与字符串编码_:ExecOptionsWithStringEncoding, 执行命令选项_:ExecOptions }
    接口 执行命令选项与字符串编码_ 扩展 执行命令选项_ {

        //@@{ 编码:encoding, 缓冲区编码_:BufferEncoding }
        编码: 缓冲区编码_;
    }

    //@@{ 执行命令选项与缓冲区编码_:ExecOptionsWithBufferEncoding, 执行命令选项_:ExecOptions }
    接口 执行命令选项与缓冲区编码_ 扩展 执行命令选项_ {

        //@@{ 编码:encoding }
        编码: 文字 | 空值; // specify `null`.
    }

    //@@{ 执行异常_:ExecException, 错误_:Error }
    接口 执行异常_ 扩展 错误_ {

        //@@{ 命令:cmd }
        命令?: 文字;

        //@@{ 杀了:killed }
        杀了?: 真假;

        //@@{ 代码:code }
        代码?: 数字;

        //@@{ 信号:signal }
        信号?: 文字;
    }

    // no `options` definitely means stdout/stderr are `string`.

    //@@{ 执行代码:exec, 执行异常_:ExecException, 子进程_:ChildProcess }
    函数 执行代码(命令: 文字, 回调?: (错误: 执行异常_ | 空值, 标准输出: 文字, 标准错误: 文字) => 无值): 子进程_;

    // `options` with `"buffer"` or `null` for `encoding` means stdout/stderr are definitely `Buffer`.

    //@@{ 执行代码:exec, 编码:encoding, "缓冲区":"buffer", 执行命令选项_:ExecOptions, 执行异常_:ExecException }
    //@@{ 缓冲区_:Buffer, 子进程_:ChildProcess }
    函数 执行代码(命令: 文字, 选项组: { 编码: "缓冲区" | 空值 } & 执行命令选项_, 回调?: (错误: 执行异常_ | 空值, 标准输出: 缓冲区_, 标准错误: 缓冲区_) => 无值): 子进程_;

    // `options` with well known `encoding` means stdout/stderr are definitely `string`.

    //@@{ 执行代码:exec, 编码:encoding, 缓冲区编码_:BufferEncoding, 执行命令选项_:ExecOptions }
    //@@{ 执行异常_:ExecException, 子进程_:ChildProcess }
    函数 执行代码(命令: 文字, 选项组: { 编码: 缓冲区编码_ } & 执行命令选项_, 回调?: (错误: 执行异常_ | 空值, 标准输出: 文字, 标准错误: 文字) => 无值): 子进程_;

    // `options` with an `encoding` whose type is `string` means stdout/stderr could either be `Buffer` or `string`.
    // There is no guarantee the `encoding` is unknown as `string` is a superset of `BufferEncoding`.

    //@@{ 执行代码:exec, 编码:encoding, 执行命令选项_:ExecOptions, 执行异常_:ExecException, 缓冲区_:Buffer }
    //@@{ 子进程_:ChildProcess }
    函数 执行代码(命令: 文字, 选项组: { 编码: 文字 } & 执行命令选项_, 回调?: (错误: 执行异常_ | 空值, 标准输出: 文字 | 缓冲区_, 标准错误: 文字 | 缓冲区_) => 无值): 子进程_;

    // `options` without an `encoding` means stdout/stderr are definitely `string`.

    //@@{ 执行代码:exec, 执行命令选项_:ExecOptions, 执行异常_:ExecException, 子进程_:ChildProcess }
    函数 执行代码(命令: 文字, 选项组: 执行命令选项_, 回调?: (错误: 执行异常_ | 空值, 标准输出: 文字, 标准错误: 文字) => 无值): 子进程_;

    // fallback if nothing else matches. Worst case is always `string | Buffer`.

    //@@{ 执行代码:exec }
    函数 执行代码(
        命令: 文字,

        //@@{ 编码:encoding, 执行命令选项_:ExecOptions }
        选项组: ({ 编码?: 文字 | 空值 } & 执行命令选项_) | 未定 | 空值,

        //@@{ 执行异常_:ExecException, 缓冲区_:Buffer }
        回调?: (错误: 执行异常_ | 空值, 标准输出: 文字 | 缓冲区_, 标准错误: 文字 | 缓冲区_) => 无值,

    //@@{ 子进程_:ChildProcess }
    ): 子进程_;

    // NOTE: This namespace provides design-time support for util.promisify. Exported members do not exist at runtime.

    //@@{ 执行代码:exec }
    名域 执行代码 {

        //@@{ __转为预设__:__promisify__, 预设_:Promise, 标准输出:stdout, 标准错误:stderr }
        函数 __转为预设__(命令: 文字): 预设_<{ 标准输出: 文字, 标准错误: 文字 }>;

        //@@{ __转为预设__:__promisify__, 编码:encoding, "缓冲区":"buffer", 执行命令选项_:ExecOptions }
        //@@{ 预设_:Promise, 标准输出:stdout, 缓冲区_:Buffer, 标准错误:stderr }
        函数 __转为预设__(命令: 文字, 选项组: { 编码: "缓冲区" | 空值 } & 执行命令选项_): 预设_<{ 标准输出: 缓冲区_, 标准错误: 缓冲区_ }>;

        //@@{ __转为预设__:__promisify__, 编码:encoding, 缓冲区编码_:BufferEncoding, 执行命令选项_:ExecOptions }
        //@@{ 预设_:Promise, 标准输出:stdout, 标准错误:stderr }
        函数 __转为预设__(命令: 文字, 选项组: { 编码: 缓冲区编码_ } & 执行命令选项_): 预设_<{ 标准输出: 文字, 标准错误: 文字 }>;

        //@@{ __转为预设__:__promisify__, 执行命令选项_:ExecOptions, 预设_:Promise, 标准输出:stdout }
        //@@{ 标准错误:stderr }
        函数 __转为预设__(命令: 文字, 选项组: 执行命令选项_): 预设_<{ 标准输出: 文字, 标准错误: 文字 }>;

        //@@{ __转为预设__:__promisify__, 编码:encoding, 执行命令选项_:ExecOptions, 预设_:Promise }
        //@@{ 标准输出:stdout, 缓冲区_:Buffer, 标准错误:stderr }
        函数 __转为预设__(命令: 文字, 选项组?: ({ 编码?: 文字 | 空值 } & 执行命令选项_) | 空值): 预设_<{ 标准输出: 文字 | 缓冲区_, 标准错误: 文字 | 缓冲区_ }>;
    }

    //@@{ 执行文件选项_:ExecFileOptions, 共同选项_:CommonOptions }
    接口 执行文件选项_ 扩展 共同选项_ {

        //@@{ 最大缓冲区:maxBuffer }
        最大缓冲区?: 数字;

        //@@{ 杀死信号:killSignal }
        杀死信号?: 文字;

        //@@{ 窗口逐字参数:windowsVerbatimArguments }
        窗口逐字参数?: 真假;
    }

    //@@{ 执行文件选项与字符串编码_:ExecFileOptionsWithStringEncoding, 执行文件选项_:ExecFileOptions }
    接口 执行文件选项与字符串编码_ 扩展 执行文件选项_ {

        //@@{ 编码:encoding, 缓冲区编码_:BufferEncoding }
        编码: 缓冲区编码_;
    }

    //@@{ 执行文件选项与缓冲区编码_:ExecFileOptionsWithBufferEncoding, 执行文件选项_:ExecFileOptions }
    接口 执行文件选项与缓冲区编码_ 扩展 执行文件选项_ {

        //@@{ 编码:encoding, "缓冲区":"buffer" }
        编码: "缓冲区" | 空值;
    }

    //@@{ 执行文件选项与其他编码_:ExecFileOptionsWithOtherEncoding, 执行文件选项_:ExecFileOptions }
    接口 执行文件选项与其他编码_ 扩展 执行文件选项_ {

        //@@{ 编码:encoding }
        编码: 文字;
    }

    //@@{ 执行文件:execFile, 子进程_:ChildProcess }
    函数 执行文件(文件: 文字): 子进程_;

    //@@{ 执行文件:execFile, 编码:encoding, 执行文件选项_:ExecFileOptions, 子进程_:ChildProcess }
    函数 执行文件(文件: 文字, 选项组: ({ 编码?: 文字 | 空值 } & 执行文件选项_) | 未定 | 空值): 子进程_;

    //@@{ 执行文件:execFile, 只读数组_:ReadonlyArray, 子进程_:ChildProcess }
    函数 执行文件(文件: 文字, 参数组?: 只读数组_<文字> | 空值): 子进程_;

    //@@{ 执行文件:execFile, 只读数组_:ReadonlyArray, 编码:encoding, 执行文件选项_:ExecFileOptions }
    //@@{ 子进程_:ChildProcess }
    函数 执行文件(文件: 文字, 参数组: 只读数组_<文字> | 未定 | 空值, 选项组: ({ 编码?: 文字 | 空值 } & 执行文件选项_) | 未定 | 空值): 子进程_;

    // no `options` definitely means stdout/stderr are `string`.

    //@@{ 执行文件:execFile, 错误_:Error, 子进程_:ChildProcess }
    函数 执行文件(文件: 文字, 回调: (错误: 错误_ | 空值, 标准输出: 文字, 标准错误: 文字) => 无值): 子进程_;

    //@@{ 执行文件:execFile, 只读数组_:ReadonlyArray, 错误_:Error, 子进程_:ChildProcess }
    函数 执行文件(文件: 文字, 参数组: 只读数组_<文字> | 未定 | 空值, 回调: (错误: 错误_ | 空值, 标准输出: 文字, 标准错误: 文字) => 无值): 子进程_;

    // `options` with `"buffer"` or `null` for `encoding` means stdout/stderr are definitely `Buffer`.

    //@@{ 执行文件:execFile, 执行文件选项与缓冲区编码_:ExecFileOptionsWithBufferEncoding }
    //@@{ 错误_:Error, 缓冲区_:Buffer, 子进程_:ChildProcess }
    函数 执行文件(文件: 文字, 选项组: 执行文件选项与缓冲区编码_, 回调: (错误: 错误_ | 空值, 标准输出: 缓冲区_, 标准错误: 缓冲区_) => 无值): 子进程_;

    //@@{ 执行文件:execFile }
    函数 执行文件(
        文件: 文字,

        //@@{ 只读数组_:ReadonlyArray }
        参数组: 只读数组_<文字> | 未定 | 空值,

        //@@{ 执行文件选项与缓冲区编码_:ExecFileOptionsWithBufferEncoding }
        选项组: 执行文件选项与缓冲区编码_,

        //@@{ 错误_:Error, 缓冲区_:Buffer }
        回调: (错误: 错误_ | 空值, 标准输出: 缓冲区_, 标准错误: 缓冲区_) => 无值,

    //@@{ 子进程_:ChildProcess }
    ): 子进程_;

    // `options` with well known `encoding` means stdout/stderr are definitely `string`.

    //@@{ 执行文件:execFile, 执行文件选项与字符串编码_:ExecFileOptionsWithStringEncoding }
    //@@{ 错误_:Error, 子进程_:ChildProcess }
    函数 执行文件(文件: 文字, 选项组: 执行文件选项与字符串编码_, 回调: (错误: 错误_ | 空值, 标准输出: 文字, 标准错误: 文字) => 无值): 子进程_;

    //@@{ 执行文件:execFile }
    函数 执行文件(
        文件: 文字,

        //@@{ 只读数组_:ReadonlyArray }
        参数组: 只读数组_<文字> | 未定 | 空值,

        //@@{ 执行文件选项与字符串编码_:ExecFileOptionsWithStringEncoding }
        选项组: 执行文件选项与字符串编码_,

        //@@{ 错误_:Error }
        回调: (错误: 错误_ | 空值, 标准输出: 文字, 标准错误: 文字) => 无值,

    //@@{ 子进程_:ChildProcess }
    ): 子进程_;

    // `options` with an `encoding` whose type is `string` means stdout/stderr could either be `Buffer` or `string`.
    // There is no guarantee the `encoding` is unknown as `string` is a superset of `BufferEncoding`.

    //@@{ 执行文件:execFile }
    函数 执行文件(
        文件: 文字,

        //@@{ 执行文件选项与其他编码_:ExecFileOptionsWithOtherEncoding }
        选项组: 执行文件选项与其他编码_,

        //@@{ 错误_:Error, 缓冲区_:Buffer }
        回调: (错误: 错误_ | 空值, 标准输出: 文字 | 缓冲区_, 标准错误: 文字 | 缓冲区_) => 无值,

    //@@{ 子进程_:ChildProcess }
    ): 子进程_;

    //@@{ 执行文件:execFile }
    函数 执行文件(
        文件: 文字,

        //@@{ 只读数组_:ReadonlyArray }
        参数组: 只读数组_<文字> | 未定 | 空值,

        //@@{ 执行文件选项与其他编码_:ExecFileOptionsWithOtherEncoding }
        选项组: 执行文件选项与其他编码_,

        //@@{ 错误_:Error, 缓冲区_:Buffer }
        回调: (错误: 错误_ | 空值, 标准输出: 文字 | 缓冲区_, 标准错误: 文字 | 缓冲区_) => 无值,

    //@@{ 子进程_:ChildProcess }
    ): 子进程_;

    // `options` without an `encoding` means stdout/stderr are definitely `string`.

    //@@{ 执行文件:execFile, 执行文件选项_:ExecFileOptions, 错误_:Error, 子进程_:ChildProcess }
    函数 执行文件(文件: 文字, 选项组: 执行文件选项_, 回调: (错误: 错误_ | 空值, 标准输出: 文字, 标准错误: 文字) => 无值): 子进程_;

    //@@{ 执行文件:execFile, 只读数组_:ReadonlyArray, 执行文件选项_:ExecFileOptions, 错误_:Error }
    //@@{ 子进程_:ChildProcess }
    函数 执行文件(文件: 文字, 参数组: 只读数组_<文字> | 未定 | 空值, 选项组: 执行文件选项_, 回调: (错误: 错误_ | 空值, 标准输出: 文字, 标准错误: 文字) => 无值): 子进程_;

    // fallback if nothing else matches. Worst case is always `string | Buffer`.

    //@@{ 执行文件:execFile }
    函数 执行文件(
        文件: 文字,

        //@@{ 编码:encoding, 执行文件选项_:ExecFileOptions }
        选项组: ({ 编码?: 文字 | 空值 } & 执行文件选项_) | 未定 | 空值,

        //@@{ 错误_:Error, 缓冲区_:Buffer }
        回调: ((错误: 错误_ | 空值, 标准输出: 文字 | 缓冲区_, 标准错误: 文字 | 缓冲区_) => 无值) | 未定 | 空值,

    //@@{ 子进程_:ChildProcess }
    ): 子进程_;

    //@@{ 执行文件:execFile }
    函数 执行文件(
        文件: 文字,

        //@@{ 只读数组_:ReadonlyArray }
        参数组: 只读数组_<文字> | 未定 | 空值,

        //@@{ 编码:encoding, 执行文件选项_:ExecFileOptions }
        选项组: ({ 编码?: 文字 | 空值 } & 执行文件选项_) | 未定 | 空值,

        //@@{ 错误_:Error, 缓冲区_:Buffer }
        回调: ((错误: 错误_ | 空值, 标准输出: 文字 | 缓冲区_, 标准错误: 文字 | 缓冲区_) => 无值) | 未定 | 空值,

    //@@{ 子进程_:ChildProcess }
    ): 子进程_;

    // NOTE: This namespace provides design-time support for util.promisify. Exported members do not exist at runtime.

    //@@{ 执行文件:execFile }
    名域 执行文件 {

        //@@{ __转为预设__:__promisify__, 预设_:Promise, 标准输出:stdout, 标准错误:stderr }
        函数 __转为预设__(文件: 文字): 预设_<{ 标准输出: 文字, 标准错误: 文字 }>;

        //@@{ __转为预设__:__promisify__, 预设_:Promise, 标准输出:stdout, 标准错误:stderr }
        函数 __转为预设__(文件: 文字, 参数组: 文字[] | 未定 | 空值): 预设_<{ 标准输出: 文字, 标准错误: 文字 }>;

        //@@{ __转为预设__:__promisify__, 执行文件选项与缓冲区编码_:ExecFileOptionsWithBufferEncoding }
        //@@{ 预设_:Promise, 标准输出:stdout, 缓冲区_:Buffer, 标准错误:stderr }
        函数 __转为预设__(文件: 文字, 选项组: 执行文件选项与缓冲区编码_): 预设_<{ 标准输出: 缓冲区_, 标准错误: 缓冲区_ }>;

        //@@{ __转为预设__:__promisify__, 执行文件选项与缓冲区编码_:ExecFileOptionsWithBufferEncoding }
        //@@{ 预设_:Promise, 标准输出:stdout, 缓冲区_:Buffer, 标准错误:stderr }
        函数 __转为预设__(文件: 文字, 参数组: 文字[] | 未定 | 空值, 选项组: 执行文件选项与缓冲区编码_): 预设_<{ 标准输出: 缓冲区_, 标准错误: 缓冲区_ }>;

        //@@{ __转为预设__:__promisify__, 执行文件选项与字符串编码_:ExecFileOptionsWithStringEncoding }
        //@@{ 预设_:Promise, 标准输出:stdout, 标准错误:stderr }
        函数 __转为预设__(文件: 文字, 选项组: 执行文件选项与字符串编码_): 预设_<{ 标准输出: 文字, 标准错误: 文字 }>;

        //@@{ __转为预设__:__promisify__, 执行文件选项与字符串编码_:ExecFileOptionsWithStringEncoding }
        //@@{ 预设_:Promise, 标准输出:stdout, 标准错误:stderr }
        函数 __转为预设__(文件: 文字, 参数组: 文字[] | 未定 | 空值, 选项组: 执行文件选项与字符串编码_): 预设_<{ 标准输出: 文字, 标准错误: 文字 }>;

        //@@{ __转为预设__:__promisify__, 执行文件选项与其他编码_:ExecFileOptionsWithOtherEncoding }
        //@@{ 预设_:Promise, 标准输出:stdout, 缓冲区_:Buffer, 标准错误:stderr }
        函数 __转为预设__(文件: 文字, 选项组: 执行文件选项与其他编码_): 预设_<{ 标准输出: 文字 | 缓冲区_, 标准错误: 文字 | 缓冲区_ }>;

        //@@{ __转为预设__:__promisify__, 执行文件选项与其他编码_:ExecFileOptionsWithOtherEncoding }
        //@@{ 预设_:Promise, 标准输出:stdout, 缓冲区_:Buffer, 标准错误:stderr }
        函数 __转为预设__(文件: 文字, 参数组: 文字[] | 未定 | 空值, 选项组: 执行文件选项与其他编码_): 预设_<{ 标准输出: 文字 | 缓冲区_, 标准错误: 文字 | 缓冲区_ }>;

        //@@{ __转为预设__:__promisify__, 执行文件选项_:ExecFileOptions, 预设_:Promise, 标准输出:stdout }
        //@@{ 标准错误:stderr }
        函数 __转为预设__(文件: 文字, 选项组: 执行文件选项_): 预设_<{ 标准输出: 文字, 标准错误: 文字 }>;

        //@@{ __转为预设__:__promisify__, 执行文件选项_:ExecFileOptions, 预设_:Promise, 标准输出:stdout }
        //@@{ 标准错误:stderr }
        函数 __转为预设__(文件: 文字, 参数组: 文字[] | 未定 | 空值, 选项组: 执行文件选项_): 预设_<{ 标准输出: 文字, 标准错误: 文字 }>;

        //@@{ __转为预设__:__promisify__, 编码:encoding, 执行文件选项_:ExecFileOptions, 预设_:Promise }
        //@@{ 标准输出:stdout, 缓冲区_:Buffer, 标准错误:stderr }
        函数 __转为预设__(文件: 文字, 选项组: ({ 编码?: 文字 | 空值 } & 执行文件选项_) | 未定 | 空值): 预设_<{ 标准输出: 文字 | 缓冲区_, 标准错误: 文字 | 缓冲区_ }>;

        //@@{ __转为预设__:__promisify__ }
        函数 __转为预设__(
            文件: 文字,
            参数组: 文字[] | 未定 | 空值,

            //@@{ 编码:encoding, 执行文件选项_:ExecFileOptions }
            选项组: ({ 编码?: 文字 | 空值 } & 执行文件选项_) | 未定 | 空值,

        //@@{ 预设_:Promise, 标准输出:stdout, 缓冲区_:Buffer, 标准错误:stderr }
        ): 预设_<{ 标准输出: 文字 | 缓冲区_, 标准错误: 文字 | 缓冲区_ }>;
    }

    //@@{ 衍生进程选项_:ForkOptions, 进程环境选项_:ProcessEnvOptions }
    接口 衍生进程选项_ 扩展 进程环境选项_ {

        //@@{ 执行路径:execPath }
        执行路径?: 文字;

        //@@{ 执行参数v:execArgv }
        执行参数v?: 文字[];

        //@@{ 沉默:silent }
        沉默?: 真假;

        //@@{ 标准输入输出:stdio, 标准输入输出选项_:StdioOptions }
        标准输入输出?: 标准输入输出选项_;

        //@@{ 与主进程分离:detached }
        与主进程分离?: 真假;

        //@@{ 窗口逐字参数:windowsVerbatimArguments }
        窗口逐字参数?: 真假;
    }

    //@@{ 衍生进程:fork, 只读数组_:ReadonlyArray, 衍生进程选项_:ForkOptions, 子进程_:ChildProcess }
    函数 衍生进程(模块路径: 文字, 参数组?: 只读数组_<文字>, 选项组?: 衍生进程选项_): 子进程_;

    //@@{ 启动进程同步选项_:SpawnSyncOptions, 共同选项_:CommonOptions }
    接口 启动进程同步选项_ 扩展 共同选项_ {

        //@@{ 参数v0:argv0 }
        参数v0?: 文字; // Not specified in the docs

        //@@{ 输入:input, 缓冲区_:Buffer, 类型数组_:TypedArray, 数据视图_:DataView }
        输入?: 文字 | 缓冲区_ | NodeJS.类型数组_ | 数据视图_;

        //@@{ 标准输入输出:stdio, 标准输入输出选项_:StdioOptions }
        标准输入输出?: 标准输入输出选项_;

        //@@{ 杀死信号:killSignal }
        杀死信号?: 文字 | 数字;

        //@@{ 最大缓冲区:maxBuffer }
        最大缓冲区?: 数字;

        //@@{ 编码:encoding }
        编码?: 文字;

        //@@{ 界面:shell }
        界面?: 真假 | 文字;

        //@@{ 窗口逐字参数:windowsVerbatimArguments }
        窗口逐字参数?: 真假;
    }

    //@@{ 启动进程同步选项与字符串编码_:SpawnSyncOptionsWithStringEncoding, 启动进程同步选项_:SpawnSyncOptions }
    接口 启动进程同步选项与字符串编码_ 扩展 启动进程同步选项_ {

        //@@{ 编码:encoding, 缓冲区编码_:BufferEncoding }
        编码: 缓冲区编码_;
    }

    //@@{ 启动进程同步选项与缓冲区编码_:SpawnSyncOptionsWithBufferEncoding, 启动进程同步选项_:SpawnSyncOptions }
    接口 启动进程同步选项与缓冲区编码_ 扩展 启动进程同步选项_ {

        //@@{ 编码:encoding }
        编码: 文字; // specify `null`.
    }

    //@@{ 启动进程同步返回_:SpawnSyncReturns }
    接口 启动进程同步返回_<T> {
        pid: 数字;

        //@@{ 输出:output }
        输出: 文字[];

        //@@{ 标准输出:stdout }
        标准输出: T;

        //@@{ 标准错误:stderr }
        标准错误: T;

        //@@{ 状态组:status }
        状态组: 数字;

        //@@{ 信号:signal }
        信号: 文字;

        //@@{ 错误:error, 错误_:Error }
        错误?: 错误_;
    }

    //@@{ 启动进程同步:spawnSync, 启动进程同步返回_:SpawnSyncReturns, 缓冲区_:Buffer }
    函数 启动进程同步(命令: 文字): 启动进程同步返回_<缓冲区_>;

    //@@{ 启动进程同步:spawnSync, 启动进程同步选项与字符串编码_:SpawnSyncOptionsWithStringEncoding }
    //@@{ 启动进程同步返回_:SpawnSyncReturns }
    函数 启动进程同步(命令: 文字, 选项组?: 启动进程同步选项与字符串编码_): 启动进程同步返回_<文字>;

    //@@{ 启动进程同步:spawnSync, 启动进程同步选项与缓冲区编码_:SpawnSyncOptionsWithBufferEncoding }
    //@@{ 启动进程同步返回_:SpawnSyncReturns, 缓冲区_:Buffer }
    函数 启动进程同步(命令: 文字, 选项组?: 启动进程同步选项与缓冲区编码_): 启动进程同步返回_<缓冲区_>;

    //@@{ 启动进程同步:spawnSync, 启动进程同步选项_:SpawnSyncOptions, 启动进程同步返回_:SpawnSyncReturns }
    //@@{ 缓冲区_:Buffer }
    函数 启动进程同步(命令: 文字, 选项组?: 启动进程同步选项_): 启动进程同步返回_<缓冲区_>;

    //@@{ 启动进程同步:spawnSync, 只读数组_:ReadonlyArray, 启动进程同步选项与字符串编码_:SpawnSyncOptionsWithStringEncoding }
    //@@{ 启动进程同步返回_:SpawnSyncReturns }
    函数 启动进程同步(命令: 文字, 参数组?: 只读数组_<文字>, 选项组?: 启动进程同步选项与字符串编码_): 启动进程同步返回_<文字>;

    //@@{ 启动进程同步:spawnSync, 只读数组_:ReadonlyArray, 启动进程同步选项与缓冲区编码_:SpawnSyncOptionsWithBufferEncoding }
    //@@{ 启动进程同步返回_:SpawnSyncReturns, 缓冲区_:Buffer }
    函数 启动进程同步(命令: 文字, 参数组?: 只读数组_<文字>, 选项组?: 启动进程同步选项与缓冲区编码_): 启动进程同步返回_<缓冲区_>;

    //@@{ 启动进程同步:spawnSync, 只读数组_:ReadonlyArray, 启动进程同步选项_:SpawnSyncOptions }
    //@@{ 启动进程同步返回_:SpawnSyncReturns, 缓冲区_:Buffer }
    函数 启动进程同步(命令: 文字, 参数组?: 只读数组_<文字>, 选项组?: 启动进程同步选项_): 启动进程同步返回_<缓冲区_>;

    //@@{ 执行命令同步选项_:ExecSyncOptions, 共同选项_:CommonOptions }
    接口 执行命令同步选项_ 扩展 共同选项_ {

        //@@{ 输入:input, 缓冲区_:Buffer, 正整数数组8_:Uint8Array }
        输入?: 文字 | 缓冲区_ | 正整数数组8_;

        //@@{ 标准输入输出:stdio, 标准输入输出选项_:StdioOptions }
        标准输入输出?: 标准输入输出选项_;

        //@@{ 界面:shell }
        界面?: 文字;

        //@@{ 杀死信号:killSignal }
        杀死信号?: 文字 | 数字;

        //@@{ 最大缓冲区:maxBuffer }
        最大缓冲区?: 数字;

        //@@{ 编码:encoding }
        编码?: 文字;
    }

    //@@{ 执行命令同步选项与字符串编码_:ExecSyncOptionsWithStringEncoding, 执行命令同步选项_:ExecSyncOptions }
    接口 执行命令同步选项与字符串编码_ 扩展 执行命令同步选项_ {

        //@@{ 编码:encoding, 缓冲区编码_:BufferEncoding }
        编码: 缓冲区编码_;
    }

    //@@{ 执行命令同步选项与缓冲区编码_:ExecSyncOptionsWithBufferEncoding, 执行命令同步选项_:ExecSyncOptions }
    接口 执行命令同步选项与缓冲区编码_ 扩展 执行命令同步选项_ {

        //@@{ 编码:encoding }
        编码: 文字; // specify `null`.
    }

    //@@{ 执行命令同步:execSync, 缓冲区_:Buffer }
    函数 执行命令同步(命令: 文字): 缓冲区_;

    //@@{ 执行命令同步:execSync, 执行命令同步选项与字符串编码_:ExecSyncOptionsWithStringEncoding }
    函数 执行命令同步(命令: 文字, 选项组?: 执行命令同步选项与字符串编码_): 文字;

    //@@{ 执行命令同步:execSync, 执行命令同步选项与缓冲区编码_:ExecSyncOptionsWithBufferEncoding }
    //@@{ 缓冲区_:Buffer }
    函数 执行命令同步(命令: 文字, 选项组?: 执行命令同步选项与缓冲区编码_): 缓冲区_;

    //@@{ 执行命令同步:execSync, 执行命令同步选项_:ExecSyncOptions, 缓冲区_:Buffer }
    函数 执行命令同步(命令: 文字, 选项组?: 执行命令同步选项_): 缓冲区_;

    //@@{ 执行文件同步选项_:ExecFileSyncOptions, 共同选项_:CommonOptions }
    接口 执行文件同步选项_ 扩展 共同选项_ {

        //@@{ 输入:input, 缓冲区_:Buffer, 类型数组_:TypedArray, 数据视图_:DataView }
        输入?: 文字 | 缓冲区_ | NodeJS.类型数组_ | 数据视图_;

        //@@{ 标准输入输出:stdio, 标准输入输出选项_:StdioOptions }
        标准输入输出?: 标准输入输出选项_;

        //@@{ 杀死信号:killSignal }
        杀死信号?: 文字 | 数字;

        //@@{ 最大缓冲区:maxBuffer }
        最大缓冲区?: 数字;

        //@@{ 编码:encoding }
        编码?: 文字;

        //@@{ 界面:shell }
        界面?: 真假 | 文字;
    }

    //@@{ 执行文件同步选项与字符串编码_:ExecFileSyncOptionsWithStringEncoding, 执行文件同步选项_:ExecFileSyncOptions }
    接口 执行文件同步选项与字符串编码_ 扩展 执行文件同步选项_ {

        //@@{ 编码:encoding, 缓冲区编码_:BufferEncoding }
        编码: 缓冲区编码_;
    }

    //@@{ 执行文件同步选项与缓冲区编码_:ExecFileSyncOptionsWithBufferEncoding, 执行文件同步选项_:ExecFileSyncOptions }
    接口 执行文件同步选项与缓冲区编码_ 扩展 执行文件同步选项_ {

        //@@{ 编码:encoding }
        编码: 文字; // specify `null`.
    }

    //@@{ 执行文件同步:execFileSync, 缓冲区_:Buffer }
    函数 执行文件同步(命令: 文字): 缓冲区_;

    //@@{ 执行文件同步:execFileSync, 执行文件同步选项与字符串编码_:ExecFileSyncOptionsWithStringEncoding }
    函数 执行文件同步(命令: 文字, 选项组?: 执行文件同步选项与字符串编码_): 文字;

    //@@{ 执行文件同步:execFileSync, 执行文件同步选项与缓冲区编码_:ExecFileSyncOptionsWithBufferEncoding }
    //@@{ 缓冲区_:Buffer }
    函数 执行文件同步(命令: 文字, 选项组?: 执行文件同步选项与缓冲区编码_): 缓冲区_;

    //@@{ 执行文件同步:execFileSync, 执行文件同步选项_:ExecFileSyncOptions, 缓冲区_:Buffer }
    函数 执行文件同步(命令: 文字, 选项组?: 执行文件同步选项_): 缓冲区_;

    //@@{ 执行文件同步:execFileSync, 只读数组_:ReadonlyArray, 执行文件同步选项与字符串编码_:ExecFileSyncOptionsWithStringEncoding }
    函数 执行文件同步(命令: 文字, 参数组?: 只读数组_<文字>, 选项组?: 执行文件同步选项与字符串编码_): 文字;

    //@@{ 执行文件同步:execFileSync, 只读数组_:ReadonlyArray, 执行文件同步选项与缓冲区编码_:ExecFileSyncOptionsWithBufferEncoding }
    //@@{ 缓冲区_:Buffer }
    函数 执行文件同步(命令: 文字, 参数组?: 只读数组_<文字>, 选项组?: 执行文件同步选项与缓冲区编码_): 缓冲区_;

    //@@{ 执行文件同步:execFileSync, 只读数组_:ReadonlyArray, 执行文件同步选项_:ExecFileSyncOptions }
    //@@{ 缓冲区_:Buffer }
    函数 执行文件同步(命令: 文字, 参数组?: 只读数组_<文字>, 选项组?: 执行文件同步选项_): 缓冲区_;
}
